```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Java Object类深度解析 | Spring Boot开发者指南</title>
    <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css">
    <link rel="stylesheet" href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.6;
        }
        .noto-serif {
            font-family: 'Noto Serif SC', serif;
        }
        .hero-gradient {
            background: linear-gradient(135deg, #2563eb 0%, #1e40af 100%);
        }
        .code-block {
            background-color: #2d3748;
            border-left: 4px solid #4299e1;
        }
        .hover-scale {
            transition: transform 0.3s ease;
        }
        .hover-scale:hover {
            transform: translateY(-5px);
        }
        .mermaid {
            background-color: white;
            padding: 20px;
            border-radius: 0.5rem;
            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
        }
        .highlight {
            position: relative;
        }
        .highlight:before {
            content: '';
            position: absolute;
            left: 0;
            top: 0;
            bottom: 0;
            width: 4px;
            background-color: #2563eb;
            border-radius: 2px;
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Hero Section -->
    <section class="hero-gradient text-white py-20 px-4 md:px-0">
        <div class="container mx-auto max-w-6xl px-4">
            <div class="flex flex-col md:flex-row items-center">
                <div class="md:w-1/2 mb-10 md:mb-0">
                    <h1 class="noto-serif text-4xl md:text-5xl font-bold leading-tight mb-4">深入理解 Java <span class="text-yellow-300">Object</span> 类</h1>
                    <p class="text-xl text-blue-100 mb-8">Spring Boot 开发者必备的核心知识体系</p>
                    <div class="flex space-x-4">
                        <a href="#content" class="bg-white text-blue-800 hover:bg-blue-100 px-6 py-3 rounded-lg font-semibold transition duration-300 flex items-center">
                            <i class="fas fa-book-open mr-2"></i> 开始阅读
                        </a>
                        <a href="#mindmap" class="border-2 border-white text-white hover:bg-white hover:text-blue-800 px-6 py-3 rounded-lg font-semibold transition duration-300 flex items-center">
                            <i class="fas fa-project-diagram mr-2"></i> 知识图谱
                        </a>
                    </div>
                </div>
                <div class="md:w-1/2 flex justify-center">
                    <div class="relative w-64 h-64 md:w-80 md:h-80">
                        <div class="absolute inset-0 bg-blue-500 rounded-full opacity-20 animate-pulse"></div>
                        <div class="absolute inset-4 bg-blue-600 rounded-full opacity-30 animate-pulse delay-100"></div>
                        <div class="absolute inset-8 bg-blue-700 rounded-full opacity-40 animate-pulse delay-200 flex items-center justify-center">
                            <div class="text-center p-6">
                                <i class="fas fa-cube text-6xl text-yellow-300 mb-2"></i>
                                <h3 class="font-bold text-white noto-serif">Object</h3>
                                <p class="text-blue-100 text-sm">Java类继承体系的根基</p>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <div class="container mx-auto max-w-6xl px-4 py-12" id="content">
        <!-- Breadcrumb -->
        <nav class="flex mb-8 text-gray-500" aria-label="Breadcrumb">
            <ol class="inline-flex items-center space-x-1 md:space-x-3">
                <li class="inline-flex items-center">
                    <a href="#" class="inline-flex items-center text-sm font-medium hover:text-blue-600">
                        <i class="fas fa-home mr-2"></i>
                        首页
                    </a>
                </li>
                <li>
                    <div class="flex items-center">
                        <i class="fas fa-angle-right text-gray-400"></i>
                        <a href="#" class="ml-1 text-sm font-medium hover:text-blue-600 md:ml-2">Java</a>
                    </div>
                </li>
                <li aria-current="page">
                    <div class="flex items-center">
                        <i class="fas fa-angle-right text-gray-400"></i>
                        <span class="ml-1 text-sm font-medium text-blue-600 md:ml-2">Object类深度解析</span>
                    </div>
                </li>
            </ol>
        </nav>

        <!-- Introduction -->
        <div class="bg-white rounded-xl shadow-md p-6 mb-12 highlight">
            <p class="text-lg text-gray-700 mb-4">
                在 Java 开发中，<code class="bg-gray-100 px-2 py-1 rounded">Object</code> 类是所有类的祖先，它是 Java 面向对象编程的基石。作为 Spring Boot 开发者，深入理解 <code class="bg-gray-100 px-2 py-1 rounded">Object</code> 类不仅能帮助你写出更高质量的代码，还能让你在面试中脱颖而出。
            </p>
            <div class="flex flex-wrap gap-4 mt-6">
                <div class="flex items-center bg-blue-50 px-4 py-2 rounded-lg">
                    <i class="fas fa-layer-group text-blue-500 mr-2"></i>
                    <span>类继承体系</span>
                </div>
                <div class="flex items-center bg-purple-50 px-4 py-2 rounded-lg">
                    <i class="fas fa-code text-purple-500 mr-2"></i>
                    <span>核心方法</span>
                </div>
                <div class="flex items-center bg-green-50 px-4 py-2 rounded-lg">
                    <i class="fas fa-leaf text-green-500 mr-2"></i>
                    <span>Spring Boot应用</span>
                </div>
                <div class="flex items-center bg-yellow-50 px-4 py-2 rounded-lg">
                    <i class="fas fa-lightbulb text-yellow-500 mr-2"></i>
                    <span>最佳实践</span>
                </div>
                <div class="flex items-center bg-red-50 px-4 py-2 rounded-lg">
                    <i class="fas fa-graduation-cap text-red-500 mr-2"></i>
                    <span>面试考点</span>
                </div>
            </div>
        </div>

        <!-- Section 1 -->
        <section class="mb-16">
            <div class="flex items-center mb-6">
                <div class="bg-blue-600 text-white w-10 h-10 rounded-full flex items-center justify-center mr-4">
                    <span class="font-bold">1</span>
                </div>
                <h2 class="text-2xl md:text-3xl font-bold noto-serif">Java 类继承体系的根基</h2>
            </div>
            
            <p class="mb-6 text-gray-700">
                <code class="bg-gray-100 px-2 py-1 rounded">Object</code> 类是 Java 中所有类的超类，它位于 <code class="bg-gray-100 px-2 py-1 rounded">java.lang</code> 包中。无论是你自定义的类，还是 Java API 中的类，甚至是 Spring Boot 框架中的各种组件，都直接或间接地继承自 <code class="bg-gray-100 px-2 py-1 rounded">Object</code> 类。
            </p>
            
            <div class="grid md:grid-cols-2 gap-8 mb-8">
                <div class="code-block text-gray-200 p-4 rounded-lg overflow-x-auto">
                    <pre><code class="language-java">// 即使没有显式继承，编译器会自动添加 extends Object
public class MySpringBootService {
    // 这个类隐式继承了 Object 类
}

// 等同于
public class MySpringBootService extends Object {
    // 显式继承 Object 类
}</code></pre>
                </div>
                <div class="bg-blue-50 p-6 rounded-lg">
                    <h3 class="font-bold text-lg mb-3 text-blue-800 noto-serif">Object 类的核心地位</h3>
                    <p class="text-gray-700 mb-4">
                        在 Java 的类型体系中，<code class="bg-gray-200 px-1 py-0.5 rounded">Object</code> 类提供了以下基础能力：
                    </p>
                    <ul class="space-y-2">
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                            <span><strong>统一的类型根基</strong>：所有引用类型都可以转型为 <code class="bg-gray-200 px-1 py-0.5 rounded">Object</code>，这为泛型编程和集合框架提供了基础</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                            <span><strong>通用行为定义</strong>：定义了所有对象共有的基本行为，如对象比较、哈希计算等</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                            <span><strong>反射和类型识别</strong>：通过 <code class="bg-gray-200 px-1 py-0.5 rounded">getClass()</code> 方法支持 Java 的反射机制</span>
                        </li>
                    </ul>
                    <p class="mt-4 text-gray-700">
                        在 Spring Boot 应用中，<code class="bg-gray-200 px-1 py-0.5 rounded">Object</code> 类的这些特性被广泛应用于依赖注入、AOP 代理、类型转换等核心功能中。
                    </p>
                </div>
            </div>
        </section>

        <!-- Section 2 -->
        <section class="mb-16">
            <div class="flex items-center mb-6">
                <div class="bg-blue-600 text-white w-10 h-10 rounded-full flex items-center justify-center mr-4">
                    <span class="font-bold">2</span>
                </div>
                <h2 class="text-2xl md:text-3xl font-bold noto-serif">Object 类的核心方法详解</h2>
            </div>
            
            <p class="mb-6 text-gray-700">
                <code class="bg-gray-100 px-2 py-1 rounded">Object</code> 类定义了 11 个方法，其中 9 个是公共方法，2 个是受保护的方法。让我们深入了解其中最常用的几个方法。
            </p>
            
            <div class="space-y-12">
                <!-- 2.1 -->
                <div class="bg-white rounded-xl shadow-sm p-6 hover-scale">
                    <h3 class="text-xl font-bold mb-4 text-blue-700 noto-serif">2.1 equals() 方法</h3>
                    <p class="mb-4 text-gray-700">
                        <code class="bg-gray-100 px-2 py-1 rounded">equals()</code> 方法用于比较两个对象是否相等。默认实现是比较对象的引用（内存地址）。
                    </p>
                    
                    <div class="code-block text-gray-200 p-4 rounded-lg mb-4 overflow-x-auto">
                        <pre><code class="language-java">@Override
public boolean equals(Object obj) {
    // 默认实现：比较引用是否指向同一对象
    return this == obj;
}</code></pre>
                    </div>
                    
                    <p class="mb-4 text-gray-700">
                        在 Spring Boot 应用中，正确重写 <code class="bg-gray-100 px-2 py-1 rounded">equals()</code> 方法对于实体类、DTO 和值对象尤为重要：
                    </p>
                    
                    <div class="code-block text-gray-200 p-4 rounded-lg overflow-x-auto">
                        <pre><code class="language-java">@Entity
public class Product {
    @Id
    private Long id;
    private String name;
    private BigDecimal price;
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        
        Product product = (Product) o;
        
        // 使用业务键比较（而非所有字段）
        return Objects.equals(id, product.id);
    }
}</code></pre>
                    </div>
                </div>
                
                <!-- 2.2 -->
                <div class="bg-white rounded-xl shadow-sm p-6 hover-scale">
                    <h3 class="text-xl font-bold mb-4 text-blue-700 noto-serif">2.2 hashCode() 方法</h3>
                    <p class="mb-4 text-gray-700">
                        <code class="bg-gray-100 px-2 py-1 rounded">hashCode()</code> 方法返回对象的哈希码，用于支持哈希表等数据结构。根据 Java 规范，如果两个对象通过 <code class="bg-gray-100 px-2 py-1 rounded">equals()</code> 方法比较相等，则它们的哈希码也必须相同。
                    </p>
                    
                    <div class="code-block text-gray-200 p-4 rounded-lg overflow-x-auto">
                        <pre><code class="language-java">@Override
public int hashCode() {
    // 配合 equals() 方法，使用相同的字段计算哈希码
    return Objects.hash(id);
}</code></pre>
                    </div>
                    
                    <p class="mt-4 text-gray-700">
                        在 Spring Boot 中，正确实现 <code class="bg-gray-100 px-2 py-1 rounded">hashCode()</code> 对于使用 Redis 缓存、使用 <code class="bg-gray-100 px-2 py-1 rounded">@Cacheable</code> 注解或将对象存储在 <code class="bg-gray-100 px-2 py-1 rounded">HashMap</code> 中至关重要。
                    </p>
                </div>
                
                <!-- 2.3 -->
                <div class="bg-white rounded-xl shadow-sm p-6 hover-scale">
                    <h3 class="text-xl font-bold mb-4 text-blue-700 noto-serif">2.3 toString() 方法</h3>
                    <p class="mb-4 text-gray-700">
                        <code class="bg-gray-100 px-2 py-1 rounded">toString()</code> 方法返回对象的字符串表示，默认实现返回类名和哈希码。
                    </p>
                    
                    <div class="code-block text-gray-200 p-4 rounded-lg overflow-x-auto">
                        <pre><code class="language-java">@Override
public String toString() {
    return "Product{" +
           "id=" + id +
           ", name='" + name + '\'' +
           ", price=" + price +
           '}';
}</code></pre>
                    </div>
                    
                    <p class="mt-4 text-gray-700">
                        在 Spring Boot 应用中，良好的 <code class="bg-gray-100 px-2 py-1 rounded">toString()</code> 实现有助于日志记录、调试和错误信息展示。Spring Boot 的自动配置类和许多核心组件都精心实现了 <code class="bg-gray-100 px-2 py-1 rounded">toString()</code> 方法，以提供清晰的日志输出。
                    </p>
                </div>
                
                <!-- 2.4 -->
                <div class="bg-white rounded-xl shadow-sm p-6 hover-scale">
                    <h3 class="text-xl font-bold mb-4 text-blue-700 noto-serif">2.4 clone() 方法</h3>
                    <p class="mb-4 text-gray-700">
                        <code class="bg-gray-100 px-2 py-1 rounded">clone()</code> 方法创建并返回对象的副本。这是一个受保护的方法，需要类实现 <code class="bg-gray-100 px-2 py-1 rounded">Cloneable</code> 接口才能使用。
                    </p>
                    
                    <div class="code-block text-gray-200 p-4 rounded-lg overflow-x-auto">
                        <pre><code class="language-java">@Entity
public class OrderItem implements Cloneable {
    private Long id;
    private Product product;
    private int quantity;
    
    @Override
    protected OrderItem clone() throws CloneNotSupportedException {
        // 浅拷贝
        return (OrderItem) super.clone();
    }
    
    // 深拷贝实现
    public OrderItem deepClone() throws CloneNotSupportedException {
        OrderItem cloned = (OrderItem) super.clone();
        // 手动复制引用类型
        if (this.product != null) {
            cloned.product = this.product.clone();
        }
        return cloned;
    }
}</code></pre>
                    </div>
                    
                    <p class="mt-4 text-gray-700">
                        在 Spring Boot 应用中，克隆通常用于：
                    </p>
                    <ul class="list-disc pl-5 space-y-1 text-gray-700">
                        <li>创建不可变对象的可变副本</li>
                        <li>实现原型设计模式</li>
                        <li>避免在多线程环境中共享可变状态</li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Section 3 -->
        <section class="mb-16">
            <div class="flex items-center mb-6">
                <div class="bg-blue-600 text-white w-10 h-10 rounded-full flex items-center justify-center mr-4">
                    <span class="font-bold">3</span>
                </div>
                <h2 class="text-2xl md:text-3xl font-bold noto-serif">Object 类在 Spring Boot 中的应用</h2>
            </div>
            
            <div class="space-y-8">
                <!-- 3.1 -->
                <div class="bg-white rounded-xl shadow-sm p-6 hover-scale">
                    <h3 class="text-xl font-bold mb-4 text-blue-700 noto-serif">3.1 依赖注入与类型转换</h3>
                    <p class="mb-4 text-gray-700">
                        Spring Boot 的依赖注入机制大量使用了 <code class="bg-gray-100 px-2 py-1 rounded">Object</code> 类的特性：
                    </p>
                    
                    <div class="code-block text-gray-200 p-4 rounded-lg overflow-x-auto">
                        <pre><code class="language-java">@Service
public class ProductService {
    
    @Autowired
    private ApplicationContext context;
    
    public void processAnyBean(String beanName) {
        // 获取任意类型的 bean，返回 Object
        Object bean = context.getBean(beanName);
        
        // 使用 instanceof 进行类型检查
        if (bean instanceof Repository) {
            System.out.println("Found a repository: " + bean.getClass().getName());
        }
        
        // 使用 getClass() 获取运行时类型
        System.out.println("Bean type: " + bean.getClass().getName());
    }
}</code></pre>
                    </div>
                </div>
                
                <!-- 3.2 -->
                <div class="bg-white rounded-xl shadow-sm p-6 hover-scale">
                    <h3 class="text-xl font-bold mb-4 text-blue-700 noto-serif">3.2 缓存与哈希表</h3>
                    <p class="mb-4 text-gray-700">
                        Spring Boot 的缓存抽象和内部实现大量依赖 <code class="bg-gray-100 px-2 py-1 rounded">equals()</code> 和 <code class="bg-gray-100 px-2 py-1 rounded">hashCode()</code> 方法：
                    </p>
                    
                    <div class="code-block text-gray-200 p-4 rounded-lg overflow-x-auto">
                        <pre><code class="language-java">@Service
public class ProductCatalogService {
    
    @Cacheable(value = "products", key = "#id")
    public Product getProductById(Long id) {
        // 从数据库加载产品
        return productRepository.findById(id).orElse(null);
    }
}</code></pre>
                    </div>
                    
                    <p class="mt-4 text-gray-700">
                        当你使用 <code class="bg-gray-100 px-2 py-1 rounded">@Cacheable</code> 注解时，Spring Boot 会使用方法参数的 <code class="bg-gray-100 px-2 py-1 rounded">hashCode()</code> 生成缓存键，并使用 <code class="bg-gray-100 px-2 py-1 rounded">equals()</code> 方法查找缓存项。如果这些方法实现不正确，可能导致缓存命中率低或缓存失效。
                    </p>
                </div>
                
                <!-- 3.3 -->
                <div class="bg-white rounded-xl shadow-sm p-6 hover-scale">
                    <h3 class="text-xl font-bold mb-4 text-blue-700 noto-serif">3.3 日志与调试</h3>
                    <p class="mb-4 text-gray-700">
                        Spring Boot 的日志系统大量使用 <code class="bg-gray-100 px-2 py-1 rounded">toString()</code> 方法：
                    </p>
                    
                    <div class="code-block text-gray-200 p-4 rounded-lg overflow-x-auto">
                        <pre><code class="language-java">@RestController
@RequestMapping("/api/products")
public class ProductController {
    
    private static final Logger logger = LoggerFactory.getLogger(ProductController.class);
    
    @PostMapping
    public ResponseEntity&lt;Product&gt; createProduct(@RequestBody Product product) {
        // 记录请求对象，会调用 product.toString()
        logger.info("Creating new product: {}", product);
        
        // 业务逻辑...
        
        return ResponseEntity.ok(product);
    }
}</code></pre>
                    </div>
                </div>
                
                <!-- 3.4 -->
                <div class="bg-white rounded-xl shadow-sm p-6 hover-scale">
                    <h3 class="text-xl font-bold mb-4 text-blue-700 noto-serif">3.4 源码解析：Spring Boot 中的 Object 应用</h3>
                    <p class="mb-4 text-gray-700">
                        让我们看看 Spring Boot 源码中如何使用 <code class="bg-gray-100 px-2 py-1 rounded">Object</code> 类的方法：
                    </p>
                    
                    <div class="code-block text-gray-200 p-4 rounded-lg overflow-x-auto">
                        <pre><code class="language-java">// 来自 Spring 的 AbstractBeanFactory 类
protected &lt;T&gt; T doGetBean(
        String name, @Nullable Class&lt;T&gt; requiredType, @Nullable Object[] args, boolean typeCheckOnly)
        throws BeansException {
    
    // 获取规范化的 bean 名称
    String beanName = transformedBeanName(name);
    Object bean;
    
    // 尝试从缓存获取单例
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        // 使用 instanceof 检查类型
        if (logger.isTraceEnabled()) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                        "' that is not fully initialized yet - a consequence of a circular reference");
            }
            else {
                logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }
        // 返回 bean 实例，可能需要类型转换
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    
    // 其他逻辑...
    
    // 最后进行类型转换
    return adaptBeanInstance(name, bean, requiredType);
}</code></pre>
                    </div>
                    
                    <p class="mt-4 text-gray-700">
                        在这段 Spring Boot 核心源码中，我们可以看到：
                    </p>
                    <ul class="list-disc pl-5 space-y-1 text-gray-700">
                        <li>使用 <code class="bg-gray-100 px-1 py-0.5 rounded">Object</code> 作为通用类型存储任意 bean 实例</li>
                        <li>使用 <code class="bg-gray-100 px-1 py-0.5 rounded">instanceof</code> 进行类型检查</li>
                        <li>在日志中调用对象的 <code class="bg-gray-100 px-1 py-0.5 rounded">toString()</code> 方法</li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Mind Map Section -->
        <section class="mb-16" id="mindmap">
            <div class="flex items-center mb-6">
                <div class="bg-blue-600 text-white w-10 h-10 rounded-full flex items-center justify-center mr-4">
                    <i class="fas fa-project-diagram"></i>
                </div>
                <h2 class="text-2xl md:text-3xl font-bold noto-serif">Object 类知识图谱</h2>
            </div>
            
            <div class="mermaid">
                graph TD
                    A[Object类] --> B[核心方法]
                    A --> C[Spring Boot应用]
                    A --> D[最佳实践]
                    A --> E[面试考点]
                    
                    B --> B1[equals()]
                    B --> B2[hashCode()]
                    B --> B3[toString()]
                    B --> B4[clone()]
                    B --> B5[getClass()]
                    
                    C --> C1[依赖注入]
                    C --> C2[类型转换]
                    C --> C3[缓存机制]
                    C --> C4[日志记录]
                    C --> C5[反射机制]
                    
                    D --> D1[正确重写equals/hashCode]
                    D --> D2[toString最佳实践]
                    D --> D3[深拷贝与浅拷贝]
                    D --> D4[Lombok简化]
                    
                    E --> E1[equals vs ==]
                    E --> E2[hashCode契约]
                    E --> E3[finalize不推荐]
                    E --> E4[类型转换]
            </div>
        </section>

        <!-- Section 4 -->
        <section class="mb-16">
            <div class="flex items-center mb-6">
                <div class="bg-blue-600 text-white w-10 h-10 rounded-full flex items-center justify-center mr-4">
                    <span class="font-bold">4</span>
                </div>
                <h2 class="text-2xl md:text-3xl font-bold noto-serif">Object 类的最佳实践</h2>
            </div>
            
            <div class="space-y-8">
                <!-- 4.1 -->
                <div class="bg-white rounded-xl shadow-sm p-6 hover-scale">
                    <h3 class="text-xl font-bold mb-4 text-blue-700 noto-serif">4.1 正确重写 equals() 和 hashCode()</h3>
                    
                    <div class="code-block text-gray-200 p-4 rounded-lg overflow-x-auto">
                        <pre><code class="language-java">@Entity
public class User {
    @Id
    private Long id;
    private String username;
    private String email;
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        
        User user = (User) o;
        
        // 使用自然业务键（通常是唯一标识符）
        return Objects.equals(username, user.username);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(username);
    }
}</code></pre>
                    </div>
                    
                    <p class="mt-4 text-gray-700 font-semibold">
                        最佳实践：
                    </p>
                    <ul class="list-disc pl-5 space-y-1 text-gray-700">
                        <li>始终同时重写这两个方法</li>
                        <li>使用相同的字段计算相等性和哈希码</li>
                        <li>考虑使用 Lombok 的 <code class="bg-gray-100 px-1 py-0.5 rounded">@EqualsAndHashCode</code> 注解简化代码</li>
                        <li>对于实体类，使用业务键而非数据库 ID 进行比较</li>
                    </ul>
                </div>
                
                <!-- 4.2 -->
                <div class="bg-white rounded-xl shadow-sm p-6 hover-scale">
                    <h3 class="text-xl font-bold mb-4 text-blue-700 noto-serif">4.2 编写有意义的 toString() 方法</h3>
                    
                    <div class="code-block text-gray-200 p-4 rounded-lg overflow-x-auto">
                        <pre><code class="language-java">@Data
@Entity
public class Order {
    @Id
    private Long id;
    
    private LocalDateTime orderDate;
    
    @ManyToOne
    private User user;
    
    @OneToMany(mappedBy = "order")
    private List&lt;OrderItem&gt; items;
    
    @Override
    public String toString() {
        return "Order{" +
               "id=" + id +
               ", orderDate=" + orderDate +
               ", user=" + (user != null ? user.getUsername() : "null") +
               ", itemCount=" + (items != null ? items.size() : 0) +
               '}';
    }
}</code></pre>
                    </div>
                    
                    <p class="mt-4 text-gray-700 font-semibold">
                        最佳实践：
                    </p>
                    <ul class="list-disc pl-5 space-y-1 text-gray-700">
                        <li>包含对象的关键标识信息</li>
                        <li>避免包含敏感数据（如密码）</li>
                        <li>避免循环引用导致的栈溢出</li>
                        <li>考虑性能影响，尤其是在日志记录中</li>
                    </ul>
                </div>
                
                <!-- 4.3 -->
                <div class="bg-white rounded-xl shadow-sm p-6 hover-scale">
                    <h3 class="text-xl font-bold mb-4 text-blue-700 noto-serif">4.3 安全地使用 clone() 方法</h3>
                    
                    <div class="code-block text-gray-200 p-4 rounded-lg overflow-x-auto">
                        <pre><code class="language-java">@Component
public class RequestContext implements Cloneable {
    private String requestId;
    private User currentUser;
    private Map&lt;String, Object&gt; attributes = new HashMap&lt;&gt;();
    
    @Override
    public RequestContext clone() {
        try {
            RequestContext cloned = (RequestContext) super.clone();
            // 深拷贝可变字段
            cloned.attributes = new HashMap&lt;&gt;(this.attributes);
            // 不拷贝用户对象，保持引用相同
            return cloned;
        } catch (CloneNotSupportedException e) {
            // 这不应该发生，因为我们实现了 Cloneable
            throw new IllegalStateException("Clone failed", e);
        }
    }
}</code></pre>
                    </div>
                    
                    <p class="mt-4 text-gray-700 font-semibold">
                        最佳实践：
                    </p>
                    <ul class="list-disc pl-5 space-y-1 text-gray-700">
                        <li>实现 <code class="bg-gray-100 px-1 py-0.5 rounded">Cloneable</code> 接口</li>
                        <li>考虑深拷贝与浅拷贝的选择</li>
                        <li>处理异常，即使它们不太可能发生</li>
                        <li>考虑使用复制构造函数或工厂方法作为替代方案</li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Section 5 -->
        <section class="mb-16">
            <div class="flex items-center mb-6">
                <div class="bg-blue-600 text-white w-10 h-10 rounded-full flex items-center justify-center mr-4">
                    <span class="font-bold">5</span>
                </div>
                <h2 class="text-2xl md:text-3xl font-bold noto-serif">面试中的 Object 类考点</h2>
            </div>
            
            <p class="mb-6 text-gray-700">
                在 Java 和 Spring Boot 面试中，<code class="bg-gray-100 px-2 py-1 rounded">Object</code> 类是常见的考点。以下是一些高频问题及其解答：
            </p>
            
            <div class="space-y-8">
                <!-- 5.1 -->
                <div class="bg-white rounded-xl shadow-sm p-6 hover-scale">
                    <h3 class="text-xl font-bold mb-4 text-blue-700 noto-serif">5.1 equals() 和 == 的区别？</h3>
                    
                    <div class="code-block text-gray-200 p-4 rounded-lg overflow-x-auto">
                        <pre><code class="language-java">String a = new String("hello");
String b = new String("hello");

// 比较引用（内存地址）
System.out.println(a == b);  // 输出: false

// 比较内容（String 重写了 equals 方法）
System.out.println(a.equals(b));  // 输出: true</code></pre>
                    </div>
                    
                    <p class="mt-4 text-gray-700 font-semibold">
                        解答：
                    </p>
                    <ul class="list-disc pl-5 space-y-1 text-gray-700">
                        <li><code class="bg-gray-100 px-1 py-0.5 rounded">==</code> 比较对象引用（内存地址）是否相同</li>
                        <li><code class="bg-gray-100 px-1 py-0.5 rounded">equals()</code> 默认实现也是比较引用，但很多类（如 String、Integer）重写了此方法来比较内容</li>
                        <li>在 Spring Boot 中，正确实现 <code class="bg-gray-100 px-1 py-0.5 rounded">equals()</code> 对于实体比较、缓存命中和集合操作至关重要</li>
                    </ul>
                </div>
                
                <!-- 5.2 -->
                <div class="bg-white rounded-xl shadow-sm p-6 hover-scale">
                    <h3 class="text-xl font-bold mb-4 text-blue-700 noto-serif">5.2 为什么重写 equals() 必须同时重写 hashCode()?</h3>
                    
                    <p class="text-gray-700 font-semibold">
                        解答：
                    </p>
                    <ul class="list-disc pl-5 space-y-1 text-gray-700">
                        <li>Java 规范要求：如果两个对象通过 <code class="bg-gray-100 px-1 py-0.5 rounded">equals()</code> 比较相等，则它们的 <code class="bg-gray-100 px-1 py-0.5 rounded">hashCode()</code> 必须返回相同的值</li>
                        <li>如果只重写 <code class="bg-gray-100 px-1 py-0.5 rounded">equals()</code> 而不重写 <code class="bg-gray-100 px-1 py-0.5 rounded">hashCode()</code>，对象在 <code class="bg-gray-100 px-1 py-0.5 rounded">HashMap</code>、<code class="bg-gray-100 px-1 py-0.5 rounded">HashSet</code> 等基于哈希的集合中会表现异常</li>
                        <li>在 Spring Boot 中，这会影响 <code class="bg-gray-100 px-1 py-0.5 rounded">@Cacheable</code> 注解的行为和 Redis 缓存的正确性</li>
                    </ul>
                </div>
                
                <!-- 5.3 -->
                <div class="bg-white rounded-xl shadow-sm p-6 hover-scale">
                    <h3 class="text-xl font-bold mb-4 text-blue-700 noto-serif">5.3 Object 类的 finalize() 方法有什么用？为什么不推荐使用？</h3>
                    
                    <p class="text-gray-700 font-semibold">
                        解答：
                    </p>
                    <ul class="list-disc pl-5 space-y-1 text-gray-700">
                        <li><code class="bg-gray-100 px-1 py-0.5 rounded">finalize()</code> 方法在对象被垃圾回收前调用，用于释放资源</li>
                        <li>不推荐使用的原因：
                            <ol class="list-decimal pl-5 mt-1 space-y-1">
                                <li>执行时机不确定</li>
                                <li>性能开销大</li>
                                <li>可能导致对象复活</li>
                                <li>从 Java 9 开始已被废弃</li>
                            </ol>
                        </li>
                        <li>在 Spring Boot 中，应使用 <code class="bg-gray-100 px-1 py-0.5 rounded">@PreDestroy</code> 注解或实现 <code class="bg-gray-100 px-1 py-0.5 rounded">DisposableBean</code> 接口来处理资源清理</li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Summary Card -->
        <div class="bg-gradient-to-r from-blue-600 to-blue-800 text-white rounded-xl p-8 mb-12 shadow-lg">
            <h2 class="text-2xl font-bold mb-4 noto-serif">关键要点总结</h2>
            <ul class="space-y-3">
                <li class="flex items-start">
                    <i class="fas fa-check-circle text-yellow-300 mt-1 mr-3"></i>
                    <span><code class="bg-blue-700 px-2 py-1 rounded">Object</code> 类是 Java 类继承体系的根基，所有类都直接或间接继承它</span>
                </li>
                <li class="flex items-start">
                    <i class="fas fa-check-circle text-yellow-300 mt-1 mr-3"></i>
                    <span>正确重写 <code class="bg-blue-700 px-2 py-1 rounded">equals()</code> 和 <code class="bg-blue-700 px-2 py-1 rounded">hashCode()</code> 是开发高质量 Java 应用的基础</span>
                </li>
                <li class="flex items-start">
                    <i class="fas fa-check-circle text-yellow-300 mt-1 mr-3"></i>
                    <span>Spring Boot 的核心功能（如依赖注入、AOP、缓存）都依赖于 <code class="bg-blue-700 px-2 py-1 rounded">Object</code> 类的方法</span>
                </li>
                <li class="flex items-start">
                    <i class="fas fa-check-circle text-yellow-300 mt-1 mr-3"></i>
                    <span>深拷贝与浅拷贝的选择取决于对象的可变性和使用场景</span>
                </li>
                <li class="flex items-start">
                    <i class="fas fa-check-circle text-yellow-300 mt-1 mr-3"></i>
                    <span><code class="bg-blue-700 px-2 py-1 rounded">Object</code> 类是 Java 面试中的高频考点，掌握其核心概念有助于面试表现</span>
                </li>
            </ul>
        </div>
    </div>

    <!-- Footer -->
    <footer class="bg-gray-900 text-gray-300 py-8">
        <div class="container mx-auto max-w-6xl px-4">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-4 md:mb-0">
                    <h3 class="text-xl font-bold text-white mb-2">技术小馆</h3>
                    <p class="text-gray-400">探索技术本质，提升开发技能</p>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="text-gray-300 hover:text-white transition duration-300 flex items-center">
                        <i class="fas fa-globe mr-2"></i>
                        http://www.yuque.com/jtostring
                    </a>
                </div>
            </div>
            <div class="border-t border-gray-800 mt-6 pt-6 text-center text-gray-500 text-sm">
                &copy; 2023 技术小馆. 保留所有权利.
            </div>
        </div>
    </footer>

    <script>
        // 初始化 Mermaid
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: false,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```